const express = require('express');
const cors = require('cors');
const crypto = require('crypto');
const WebSocket = require('ws');
const path = require('path');
const tencentcloud = require('tencentcloud-sdk-nodejs');
require('dotenv').config();

const app = express();
const PORT = process.env.PORT || 3012; // 更改端口号为3012以避免冲突

// 中间件
app.use(cors());
app.use(express.json());

// 检查必要的环境变量
const requiredEnvVars = ['SPARK_API_KEY', 'SPARK_API_SECRET', 'SPARK_APP_ID'];
const missingEnvVars = requiredEnvVars.filter(varName => !process.env[varName]);

if (missingEnvVars.length > 0) {
  console.error('错误: 缺少必要的环境变量:', missingEnvVars.join(', '));
  console.error('请设置以下环境变量:');
  missingEnvVars.forEach(varName => {
    console.error(`  ${varName}=your_${varName.toLowerCase()}_here`);
  });
  console.error('\n提示: 可以在项目根目录创建 .env 文件来配置这些变量');
  process.exit(1);
}

// 讯飞星火AI配置
const SPARK_CONFIG = {
  models: {
    'v4.0Ultra': {
      domain: '4.0Ultra',
      url: 'wss://spark-api.xf-yun.com/v4.0/chat'
    },
    'max-32k': {
      domain: 'max-32k',
      url: 'wss://spark-api.xf-yun.com/chat/max-32k'
    },
    'max': {
      domain: 'generalv3.5',
      url: 'wss://spark-api.xf-yun.com/v3.5/chat'
    },
    'pro-128k': {
      domain: 'pro-128k',
      url: 'wss://spark-api.xf-yun.com/chat/pro-128k'
    },
    'pro': {
      domain: 'generalv3',
      url: 'wss://spark-api.xf-yun.com/v3.1/chat'
    },
    'lite': {
      domain: 'lite',
      url: 'wss://spark-api.xf-yun.com/v1.1/chat'
    }
  }
};

/**
 * 生成讯飞星火AI WebSocket连接的鉴权URL
 * @param {string} appId 应用ID
 * @param {string} apiKey API密钥
 * @param {string} apiSecret API密钥密文
 * @param {string} model 模型版本
 * @returns {string} 鉴权后的WebSocket URL
 */
function generateAuthUrl(appId, apiKey, apiSecret, model = 'max') {
  // 获取模型配置
  const modelConfig = SPARK_CONFIG.models[model] || SPARK_CONFIG.models.max;
  
  // 生成RFC1123格式的时间戳
  const date = new Date().toUTCString();
  
  // 从URL中提取路径
  const urlMatch = modelConfig.url.match(/xf-yun\.com\/([^?#]+)$/);
  const path = urlMatch?.[1] ?? '';
  
  // 构建签名原始字符串 - 讯飞星火AI官方格式
  const signatureOrigin = `host: spark-api.xf-yun.com\ndate: ${date}\nGET /${path} HTTP/1.1`;
  
  // 使用HMAC-SHA256加密
  const signature = crypto
    .createHmac('sha256', apiSecret)
    .update(signatureOrigin)
    .digest('base64');
  
  // 构建授权头
  const authorizationOrigin = `api_key="${apiKey}", algorithm="hmac-sha256", headers="host date request-line", signature="${signature}"`;
  const authorization = Buffer.from(authorizationOrigin).toString('base64');
  
  // 构建最终URL
  const authUrl = `${modelConfig.url}?authorization=${authorization}&date=${encodeURIComponent(date)}&host=spark-api.xf-yun.com`;
  
  return authUrl;
}

// AI分析端点 - WebSocket版本
app.post('/api/ai/analyze', async (req, res) => {
  try {
    console.log('收到AI分析请求:', JSON.stringify(req.body, null, 2));
    
    // 兼容前端两种请求格式
    let drugs = [];
    let interactionDescription = '';
    let model = 'max';
    
    if (req.body.drugs && Array.isArray(req.body.drugs)) {
      // 新格式: { drugs: ['药物1', '药物2'] }
      drugs = req.body.drugs;
      interactionDescription = req.body.interactionDescription || `药物相互作用分析: ${drugs.join(' 和 ')}`;
      model = req.body.model || 'max';
    } else if (req.body.drug1 && req.body.drug2) {
      // 旧格式: { drug1: '药物1', drug2: '药物2', interactionDescription: '描述' }
      drugs = [req.body.drug1, req.body.drug2];
      interactionDescription = req.body.interactionDescription || `药物相互作用分析: ${req.body.drug1} 和 ${req.body.drug2}`;
      model = req.body.model || 'max';
    } else {
      console.error('错误: 未提供有效的药物信息');
      return res.status(400).json({ error: '请提供有效的药物信息' });
    }
    
    if (drugs.length === 0) {
      console.error('错误: 未提供药物列表');
      return res.status(400).json({ error: '请提供药物列表' });
    }
    
    console.log('药物列表:', drugs);
    console.log('相互作用描述:', interactionDescription);
    console.log('调用AI服务，模型:', model);
    
    // 生成鉴权URL
    const authUrl = generateAuthUrl(
      process.env.SPARK_APP_ID,
      process.env.SPARK_API_KEY,
      process.env.SPARK_API_SECRET,
      model
    );
    
    console.log('鉴权URL已生成');
    
    // 创建WebSocket连接
    const socket = new WebSocket(authUrl);
    
    let fullResponse = '';
    let responseSent = false;
    
    // 设置超时
    const timeout = setTimeout(() => {
      if (!responseSent) {
        responseSent = true;
        socket.close();
        if (!res.headersSent) {
          res.status(500).json({
            error: 'AI服务请求超时'
          });
        }
      }
    }, 30000); // 30秒超时
    
    // 连接打开时发送消息
    socket.onopen = () => {
      console.log('WebSocket连接已建立');
      
      // 获取模型配置
      const modelConfig = SPARK_CONFIG.models[model] || SPARK_CONFIG.models.max;
      
      // 构建请求参数，严格按照讯飞星火AI的格式要求
      const request = {
        header: {
          app_id: process.env.SPARK_APP_ID,
          uid: "server"
        },
        parameter: {
          chat: {
            domain: modelConfig.domain,
            temperature: 0.5,
            max_tokens: 2048
          }
        },
        payload: {
          message: {
            text: [
              {
                role: "system",
                content: "你是一名专业的临床药师，擅长药物相互作用分析。请根据提供的药物相互作用信息，生成一份专业的分析报告。"
              },
              {
                role: "user",
                content: `请分析以下药物相互作用：${interactionDescription}。请详细说明可能的相互作用机制、临床风险、监测建议和处理措施。`
              }
            ]
          }
        }
      };
      
      // 发送请求
      const requestPayload = JSON.stringify(request);
      socket.send(requestPayload);
      
      console.log('已发送AI服务请求');
    };
    
    // 接收消息
    socket.onmessage = (event) => {
      try {
        const data = JSON.parse(event.data);
        
        // 检查是否有错误
        if (data.header.code !== 0) {
          const errorMessage = data.header.message || '未知错误';
          const errorCode = data.header.code || '未知错误码';
          
          if (!responseSent) {
            responseSent = true;
            clearTimeout(timeout);
            socket.close();
            console.error('AI服务返回错误，设置responseSent=true:', errorMessage, '错误码:', errorCode);
            if (!res.headersSent) {
              res.status(500).json({
                error: `AI服务错误 [${errorCode}]: ${errorMessage}`
              });
            }
          } else {
            console.log('AI服务返回错误，但responseSent已为true，跳过处理');
          }
          return;
        }
        
        // 获取AI回复内容
        if (data.payload.choices && data.payload.choices.text && data.payload.choices.text[0]) {
          const content = data.payload.choices.text[0].content;
          if (content && typeof content === 'string') {
            fullResponse += content;
          }
        }
        
        // 检查是否是最后一次回复
        if (data.header.status === 2) {
          console.log('收到最终AI服务响应，内容长度:', fullResponse.length);
          
          clearTimeout(timeout);
          socket.close();
          
          // 确保响应不为空
          if (!fullResponse.trim()) {
            fullResponse = '未收到有效的AI分析结果，请稍后重试。';
          }
          
          // 检查响应是否已经发送
          if (!responseSent && !res.headersSent) {
            responseSent = true;
            console.log('准备发送最终响应到前端...');
            res.json({
              success: true,
              analysis: fullResponse
            });
            console.log('最终响应已发送到前端');
          } else if (responseSent) {
            console.warn('响应已经标记为已发送，跳过最终响应处理');
          } else if (res.headersSent) {
            console.warn('响应头已发送，跳过最终响应处理');
          }
        } else {
          // 中间响应，只记录一次日志避免过多输出
          if (fullResponse.length < 100) {
            console.log('收到AI服务中间响应，当前内容长度:', fullResponse.length);
          }
        }
      } catch (error) {
        console.error('解析AI回复时出错:', error);
        if (!responseSent) {
          responseSent = true;
          clearTimeout(timeout);
          socket.close();
          console.error('解析错误，设置responseSent=true');
          if (!res.headersSent) {
            res.status(500).json({
              error: `解析AI回复时出错: ${error.message}`
            });
          }
        } else {
          console.log('解析错误，但responseSent已为true，跳过处理');
        }
      }
    };
    
    // 连接错误处理
    socket.onerror = (error) => {
      console.error('WebSocket连接错误:', error);
      if (!responseSent) {
        responseSent = true;
        clearTimeout(timeout);
        console.error('连接错误，设置responseSent=true');
        if (!res.headersSent) {
          res.status(500).json({
            error: `WebSocket连接错误: ${error.message || '未知错误'}`
          });
        }
      } else {
        console.log('连接错误，但responseSent已为true，跳过处理');
      }
    };
    
    // 连接关闭处理
    socket.onclose = (event) => {
      console.log('WebSocket连接关闭，代码:', event.code, '原因:', event.reason);
      clearTimeout(timeout);
      
      // 如果连接关闭但响应还未发送，且内容不为空，则发送响应
      if (!responseSent && fullResponse && !res.headersSent) {
        responseSent = true;
        console.log('连接关闭时发送最终响应，内容长度:', fullResponse.length);
        // 确保响应不为空
        if (!fullResponse.trim()) {
          fullResponse = '未收到有效的AI分析结果，请稍后重试。';
        }
        res.json({
          success: true,
          analysis: fullResponse
        });
        console.log('连接关闭时响应已发送到前端');
      } else if (responseSent) {
        console.log('连接关闭，响应已发送');
      } else if (res.headersSent) {
        console.log('连接关闭，响应头已发送');
      } else {
        console.log('连接关闭，无内容发送');
      }
    };
  } catch (error) {
    console.error('调用讯飞星火AI时出错:', error);
    if (!res.headersSent) {
      res.status(500).json({
        error: `调用AI服务时出错: ${error.message || '未知错误'}`
      });
    }
  }
});

// 健康检查端点
app.get('/api/health', (req, res) => {
  res.json({ status: 'OK', message: '服务器运行正常' });
});

// 翻译文本段落的辅助函数
async function translateSegment(textSegment, targetLanguage, secretId, secretKey) {
  const TmtClient = tencentcloud.tmt.v20180321.Client;
  
  const clientConfig = {
    credential: {
      secretId: secretId,
      secretKey: secretKey,
    },
    region: "ap-beijing",
    profile: {
      httpProfile: {
        endpoint: "tmt.tencentcloudapi.com",
      },
    },
  };
  
  const client = new TmtClient(clientConfig);
  
  // 将前端语言代码映射到腾讯云支持的语言代码
  const languageMap = {
    'zh': 'zh',     // 中文
    'en': 'en',     // 英文
    'ja': 'ja',     // 日文
    'ko': 'ko',     // 韩文
    'fr': 'fr',     // 法文
    'es': 'es',     // 西班牙文
    'ru': 'ru',     // 俄文
    'de': 'de',     // 德文
    'it': 'it',     // 意大利文
    'tr': 'tr',     // 土耳其文
    'pt': 'pt',     // 葡萄牙文
    'vi': 'vi',     // 越南文
    'id': 'id',     // 印度尼西亚文
    'th': 'th',     // 泰文
    'ms': 'ms'      // 马来文
  };
  
  // 自动检测源语言，支持多种语言互译
  const source = 'auto'; // 让腾讯云自动检测源语言
  const target = languageMap[targetLanguage] || 'en'; // 默认目标语言为英文
  
  const params = {
    SourceText: textSegment,
    Source: source,
    Target: target,
    ProjectId: 0
  };
  
  const data = await client.TextTranslate(params);
  return data.TargetText;
}

// 腾讯云翻译API代理端点
app.post('/api/translate', async (req, res) => {
  try {
    const { text, targetLanguage } = req.body;
    
    if (!text) {
      return res.status(400).json({ error: '请提供要翻译的文本' });
    }
    
    // 检查是否配置了腾讯云翻译服务
    const secretId = process.env.TENCENT_SECRET_ID;
    const secretKey = process.env.TENCENT_SECRET_KEY;
    
    if (!secretId || !secretKey) {
      console.warn('警告: 未配置腾讯云密钥，将返回原文');
      return res.json({ 
        success: true, 
        translatedText: text,
        message: '腾讯云翻译服务未配置，返回原文'
      });
    }
    
    // 如果文本长度超过6000字符，需要分段翻译
    if (text.length > 6000) {
      // 按句号分割文本，避免截断句子
      const sentences = text.split(/(?<=[.!?。！？])\s*/);
      let translatedText = '';
      
      // 逐段翻译
      let currentSegment = '';
      for (const sentence of sentences) {
        // 如果加上当前句子会超过限制，则先翻译当前段
        if (currentSegment.length + sentence.length > 5000) {
          if (currentSegment.length > 0) {
            const segmentTranslation = await translateSegment(currentSegment, targetLanguage || "zh", secretId, secretKey);
            translatedText += segmentTranslation;
            currentSegment = sentence;
          } else {
            // 单个句子就超过限制，强制分割
            const segmentTranslation = await translateSegment(sentence.substring(0, 5000), targetLanguage || "zh", secretId, secretKey);
            translatedText += segmentTranslation;
            currentSegment = sentence.substring(5000);
          }
        } else {
          currentSegment += sentence;
        }
      }
      
      // 翻译最后一段
      if (currentSegment.length > 0) {
        const segmentTranslation = await translateSegment(currentSegment, targetLanguage || "zh", secretId, secretKey);
        translatedText += segmentTranslation;
      }
      
      return res.json({ 
        success: true, 
        translatedText,
        engine: 'tencent-cloud',
        segmented: true
      });
    } else {
      // 文本长度未超过限制，直接翻译
      const translatedText = await translateSegment(text, targetLanguage || "zh", secretId, secretKey);
      
      return res.json({ 
        success: true, 
        translatedText,
        engine: 'tencent-cloud',
        segmented: false
      });
    }
  } catch (error) {
    console.error('翻译服务出错:', error);
    
    // 处理特定的错误情况
    let errorMessage = error.message || '未知错误';
    if (error.code) {
      errorMessage = `${error.code}: ${errorMessage}`;
    }
    
    res.status(500).json({ 
      error: `翻译服务出错: ${errorMessage}` 
    });
  }
});

// 启动服务器
app.listen(PORT, () => {
  console.log(`🚀 服务器运行在 http://localhost:${PORT}`);
  console.log('📊 环境变量检查:');
  console.log(`   SPARK_API_KEY: ${process.env.SPARK_API_KEY ? '已配置' : '未配置'}`);
  console.log(`   SPARK_API_SECRET: ${process.env.SPARK_API_SECRET ? '已配置' : '未配置'}`);
  console.log(`   SPARK_APP_ID: ${process.env.SPARK_APP_ID ? '已配置' : '未配置'}`);
  console.log('🔗 前后端整合完成，可通过前端访问');
  console.log('🌐 访问地址: http://localhost:5173 (前端)');
  console.log(`🔧 后端API: http://localhost:${PORT}/api`);
});